package com.zgkxzx.算法.动态规划;

/**
 * 创建者 zgkxzx
 * 日期   12/26/17
 * 描述
 */

public class MaxChildSequece {


    /**

                        C[i-1,j-1]+1 (xi=yj)
     Length(max) =
                        Max(C[i-1,j],C[i,j-1]) (xi!=yj)



     动态规划（Dynamic Programming）是一种设计的技巧，是解决多阶段决策过程最优化问题的通用方法。

     基本思想：将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解（这部分与分治法相似）。
     与分治法不同的是，适合于用动态规划求解的问题，经分解得到的子问题往往不是互相独立的。若用分治法来解这类问题，
     则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，
     这样就可以避免大量的重复计算，节省时间。通常可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，
     就将其结果填入表中。这就是动态规划的基本思路。
     */

    /**
     * 最大子序列
     * @param sub1
     * @param sub2
     * @return
     */
    public static int calc(String sub1, String sub2) {
        int length1 = sub1.length();
        int length2 = sub2.length();

        //矩阵
        int[][] seq = new int[length1][length2];

        char[] chars1 = sub1.toCharArray();
        char[] chars2 = sub2.toCharArray();

        for (int i = 0; i < length1; i++) {
            if (chars2[0] == chars1[i]) {
                seq[i][0] = 1;
                for (int j = i + 1; j < length1; j++) {
                    seq[j][0] = 1;
                }
                break;
            }
        }

        for (int i = 0; i < length2; i++) {
            if (chars1[0] == chars2[i]) {
                seq[0][i] = 1;
                for (int j = i + 1; j < length2; j++) {
                    seq[0][j] = 1;
                }
                break;
            }
        }

        for (int i = 1; i < length1; i++)
            for (int j = 1; j < length2; j++) {
                if (chars1[i] == chars2[j]) {
                    seq[i][j] = 1 + seq[i - 1][j - 1];
                } else {
                    seq[i][j] = Math.max(seq[i][j - 1], seq[i - 1][j]);
                }
            }

        for (int i = 1; i < length1; i++) {
            for (int j = 1; j < length2; j++) {
                System.out.print(seq[i][j] + " ");
            }
            System.out.println();
        }


        return seq[length1 - 1][length2 - 1];
    }

}
